<!DOCTYPE html>
<html>
<!--
Copyright 2011 The Closure Library Authors. All Rights Reserved.

Use of this source code is governed by the Apache License, Version 2.0.
See the COPYING file for details.
-->
<head>
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>Closure Unit Tests - goog.vec.Quaternion</title>
<script src="../base.js"></script>
<script>
  goog.require('goog.vec.Float32Array');
  goog.require('goog.vec.Mat4');
  goog.require('goog.vec.Quaternion');
  goog.require('goog.vec.Vec3');
  goog.require('goog.vec.Vec4');
  goog.require('goog.testing.jsunit');
</script>
</head>
<body>
<script>

  function testConjugate() {
    var q0 = goog.vec.Quaternion.createFloat32FromValues(1, 2, 3, 4);
    var q1 = goog.vec.Quaternion.createFloat32();

    goog.vec.Quaternion.conjugate(q0, q1);
    assertElementsEquals([1, 2, 3, 4], q0);
    assertElementsEquals([-1, -2, -3, 4], q1);

    goog.vec.Quaternion.conjugate(q1, q1);
    assertElementsEquals([1, 2, 3, 4], q1);
  }

  function testConcat() {
    var q0 = goog.vec.Quaternion.createFloat32FromValues(1, 2, 3, 4);
    var q1 = goog.vec.Quaternion.createFloat32FromValues(2, 3, 4, 5);
    var q2 = goog.vec.Quaternion.createFloat32();
    goog.vec.Quaternion.concat(q0, q1, q2);
    assertElementsEquals([12, 24, 30, 0], q2);

    goog.vec.Quaternion.concat(q0, q1, q0);
    assertElementsEquals([12, 24, 30, 0], q0);
  }

  function testSlerp() {
    var q0 = goog.vec.Quaternion.createFloat32FromValues(1, 2, 3, 4);
    var q1 = goog.vec.Quaternion.createFloat32FromValues(5, -6, 7, -8);
    var q2 = goog.vec.Quaternion.createFloat32();

    goog.vec.Quaternion.slerp(q0, q1, 0, q2);
    assertElementsEquals([5, -6, 7, -8], q2);

    goog.vec.Quaternion.normalize(q0, q0);
    goog.vec.Quaternion.normalize(q1, q1);

    goog.vec.Quaternion.slerp(q0, q0, .5, q2);
    assertElementsEquals(q0, q2);

    goog.vec.Quaternion.slerp(q0, q1, 0, q2);
    assertElementsEquals(q0, q2);

    goog.vec.Quaternion.slerp(q0, q1, 1, q2);
    if (q1[3] * q2[3] < 0) {
      goog.vec.Quaternion.negate(q2, q2);
    }
    assertElementsEquals(q1, q2);

    goog.vec.Quaternion.slerp(q0, q1, .3, q2);
    assertElementsRoughlyEqual(
        [-0.000501537327541, 0.4817612034640, 0.2398775270769, 0.842831337398],
        q2, goog.vec.EPSILON);

    goog.vec.Quaternion.slerp(q0, q1, .5, q2);
    assertElementsRoughlyEqual(
        [-0.1243045421171, 0.51879732466, 0.0107895780990, 0.845743047108],
        q2, goog.vec.EPSILON);

    goog.vec.Quaternion.slerp(q0, q1, .8, q0);
    assertElementsRoughlyEqual(
        [-0.291353561485, 0.506925588797, -0.3292443285721, 0.741442999653],
        q0, goog.vec.EPSILON);
  }

  function testToRotMatrix() {
    var q0 = goog.vec.Quaternion.createFloat32FromValues(
        0.22094256606638, 0.53340203646030,
        0.64777022739548, 0.497051689967954);
    var m0 = goog.vec.Mat4.createFloat32();
    goog.vec.Quaternion.toRotationMatrix4(q0, m0);

    assertElementsRoughlyEqual(
        [-0.408248, 0.8796528, -0.244016935, 0,
         -0.4082482, 0.06315623, 0.9106836, 0,
         0.8164965, 0.47140452, 0.3333333, 0,
         0, 0, 0, 1],
        m0, goog.vec.EPSILON);
  }

  function testFromRotMatrix() {
    var m0 = goog.vec.Mat4.createFloat32FromValues(
        -0.408248, 0.8796528, -0.244016935, 0,
        -0.4082482, 0.06315623, 0.9106836, 0,
        0.8164965, 0.47140452, 0.3333333, 0,
        0, 0, 0, 1);
    var q0 = goog.vec.Quaternion.createFloat32();
    goog.vec.Quaternion.fromRotationMatrix4(m0, q0);
    assertElementsRoughlyEqual(
        [0.22094256606638, 0.53340203646030,
         0.64777022739548, 0.497051689967954],
        q0, goog.vec.EPSILON);
  }

  function testToAngleAxis() {
    // Test the identity rotation.
    var q0 = goog.vec.Quaternion.createFloat32FromValues(0, 0, 0, 1);
    var axis = goog.vec.Vec3.createFloat32();
    var angle = goog.vec.Quaternion.toAngleAxis(q0, axis);
    assertRoughlyEquals(0.0, angle, goog.vec.EPSILON);
    assertElementsRoughlyEqual([1, 0, 0], axis, goog.vec.EPSILON);

    // Check equivalent representations of the same rotation.
    goog.vec.Quaternion.setFromValues(
        q0, -0.288675032, 0.622008682, -0.17254543, 0.70710678);
    angle = goog.vec.Quaternion.toAngleAxis(q0, axis);
    assertRoughlyEquals(Math.PI / 2, angle, goog.vec.EPSILON);
    assertElementsRoughlyEqual([-0.408248, 0.8796528, -0.244016],
                               axis, goog.vec.EPSILON);
    // The polar opposite unit quaternion is the same rotation, so we
    // check that the negated quaternion yields the negated angle and axis.
    goog.vec.Quaternion.negate(q0, q0);
    angle = goog.vec.Quaternion.toAngleAxis(q0, axis);
    assertRoughlyEquals(-Math.PI / 2, angle, goog.vec.EPSILON);
    assertElementsRoughlyEqual([0.408248, -0.8796528, 0.244016],
                               axis, goog.vec.EPSILON);

    // Verify that the inverse rotation yields the inverse axis.
    goog.vec.Quaternion.conjugate(q0, q0);
    angle = goog.vec.Quaternion.toAngleAxis(q0, axis);
    assertRoughlyEquals(-Math.PI / 2, angle, goog.vec.EPSILON);
    assertElementsRoughlyEqual([-0.408248, 0.8796528, -0.244016],
                               axis, goog.vec.EPSILON);
  }

  function testFromAngleAxis() {
    // Test identity rotation (zero angle or multiples of TWO_PI).
    var angle = 0.0;
    var axis = goog.vec.Vec3.createFloat32FromValues(-0.408248, 0.8796528,
                                                     -0.244016);
    var q0 = goog.vec.Quaternion.createFloat32();
    goog.vec.Quaternion.fromAngleAxis(angle, axis, q0);
    assertElementsRoughlyEqual([0, 0, 0, 1], q0, goog.vec.EPSILON);
    angle = 4 * Math.PI;
    goog.vec.Quaternion.fromAngleAxis(angle, axis, q0);
    assertElementsRoughlyEqual([0, 0, 0, 1], q0, goog.vec.EPSILON);

    // General test of various rotations around axes of different lengths.
    angle = Math.PI / 2;
    goog.vec.Quaternion.fromAngleAxis(angle, axis, q0);
    assertElementsRoughlyEqual(
        [-0.288675032, 0.622008682, -0.17254543, 0.70710678],
        q0, goog.vec.EPSILON);
    // Angle multiples of TWO_PI with a scaled axis should be the same.
    angle += 4 * Math.PI;
    goog.vec.Vec3.scale(axis, 7.0, axis);
    goog.vec.Quaternion.fromAngleAxis(angle, axis, q0);
    assertElementsRoughlyEqual(
        [-0.288675032, 0.622008682, -0.17254543, 0.70710678],
        q0, goog.vec.EPSILON);
    goog.vec.Vec3.setFromValues(axis, 1, 5, 8);
    goog.vec.Quaternion.fromAngleAxis(angle, axis, q0);
    assertElementsRoughlyEqual(
        [0.074535599, 0.372677996, 0.596284794, 0.70710678],
        q0, goog.vec.EPSILON);

    // Check equivalent representations of the same rotation.
    angle = Math.PI / 5;
    goog.vec.Vec3.setFromValues(axis, 5, -2, -10);
    goog.vec.Quaternion.fromAngleAxis(angle, axis, q0);
    assertElementsRoughlyEqual(
        [0.136037146, -0.0544148586, -0.27207429, 0.951056516],
        q0, goog.vec.EPSILON);
    // The negated angle and axis should yield the same rotation.
    angle = -Math.PI / 5;
    goog.vec.Vec3.negate(axis, axis);
    goog.vec.Quaternion.fromAngleAxis(angle, axis, q0);
    assertElementsRoughlyEqual(
        [0.136037146, -0.0544148586, -0.27207429, 0.951056516],
        q0, goog.vec.EPSILON);
  }

</script>
</body>
